const PENDING = "pending";
const FULFILLED = "fulfilled";
const REJECTED = "rejected";

class Promise{
	static resolve(value){
		// 伪代码 ：思路
		// 返回的肯定是一个Promise实例
		// 判断value是否为Promise实例？
		// 是：直接返回
		// 否：创建一个新的Promise实例，状态为fulfilled,值为value
		if(value instanceof Promise) return value;
		else{
			return new Promise(resolve=>resolve(value))
		}
	}
	static reject(value){
		// 伪代码：思路
		// 1- 返回的是一个失败的Promise实例
		// 2- 接收的值即是失败值。
		return new Promise((resolve,reject)=>{
			reject(value);
		})
	}
	static all(value){
		// 思路：
		// 1- value是一个数组
		// 2- 返回的是一个新的Promise实例
		// 3- 返回的Promise实例状态和值受value的影响
		///   3-1 value中元素如果全部成功，那么返回的Promise实例状态即为成功，
		//    成功值是数组，数组的元素即为value元素对应的成功值
		//    3-2 只要有一个失败，返回的即是失败值
		let arr= new Array(value.length);
		let num = 0;
		return new Promise((resolve,reject)=>{
			value.forEach(((item,index)=>{
				item.then(v=>{
					arr[index] = v;
					if(++num === value.length){
						resolve(arr);
					}
				},reason=>{
					reject(reason);
				})
			}))
		})
	}
	static race(value){
		// 返回一个新Promise实例,
		// 接收的是数组，看谁先执行完
		return new Promise((resolve,reject)=>{
			value.forEach(item=>{
				// item.then(function(value){
				// 	resolve(value)
				// },function(reason){
				// 	reject(reason);
				// })
				
				item.then(resolve,reject);
			})
		})
	}
	constructor(executor) {
		if (!(executor instanceof Function)) {
			throw "executor类型错误！"
		}
		this.state = PENDING;// 状态
		this.result = undefined;// 状态值
		this.callback = [];
		// 更改状态为fulfilled,成功值为value
		const _onResolve = function (value) {
			// 如果状态被更改，那么不允许执行后续代码（状态只允许更改一次）
			if (this.state !== PENDING) return;
			this.state = FULFILLED;
			this.result = value;
			if(this.callback.length) this.callback.forEach(item=>item.onResolved())
		}
		// 更改状态为rejected,失败的值为value
		const _onReject = function (value) {
			if (this.state !== PENDING) return;
			this.state = REJECTED;
			this.result = value;
			if(this.callback.length) this.callback.forEach(item=>item.onRejected())
		}
		try {
			// 调用执行器函数
			executor(_onResolve.bind(this), _onReject.bind(this));
		} catch (value) {
			// _onReject.bind(this,value)();
			_onReject.call(this, value)
		}
	}
	// onResolved:成功回调
	// onRejected:失败回调
	then(onResolved, onRejected) {
		// 如果onResolved不是函数，成功回调默认为value=>value
		if(!(onResolved instanceof Function)){
			onResolved = value=>value;
		}
		// 如果onRejected不是函数，失败回调默认值为reason=>{throw reason};
		if(!(onRejected instanceof Function)){
			onRejected = reason=>{
				throw reason;
			}
		}
		// this--->p
		return new Promise(function (resolve, reject) {
			const _common = function (cb) {
				setTimeout(() => {
					try {
						// 调用成功回调，成功回调的返回值会影响返回的Promise实例状态和值
						const value = cb(this.result);
						// value是否为Promise实例
						if (value instanceof Promise) {
							// 是,将then函数返回的Promise实例的状态以及值设置为与value的状态和值相同。
							value.then(resolve, reject);
						} else {
							// 不是Promise实例，将then函数返回的Promise实例设置为成功，值为value
							resolve(value);
						}
					} catch (err) {
						reject(err);
					}
				})
				
			}
			// 判断当前状态是否为成功
			if (this.state === FULFILLED) {
				_common.call(this, onResolved);
			} else if (this.state === REJECTED) {
				_common.call(this, onRejected);
			} else {
				// 状态未更改，执行器函数中拥有异步行为
				this.callback.push({
					onResolved:_common.bind(this,onResolved),
					onRejected:_common.bind(this,onRejected)
				})
			}
		}.bind(this))
	}
	// onRejected:失败回调
	catch(onRejected) {
		return this.then(undefined,onRejected);
	}
}

export default Promise;